package com.csjbot.weedle_auto.SerialServer.util.bean

import java.io.InputStream

/**
 * ClassName: NetDataTypeTransform 数据类型转换 <br></br>
 * date: 2017年8月23日修订版 下午2:39:42 <br></br>
 *
 * @author 陈奇
 */
object NetDataTypeTransform {

//    /**
//     * byte转换为char
//     *
//     * @param b
//     * @return
//     */
//    @Deprecated("")
//    fun bytesToChar(b: ByteArray): Char {
//        return (((b[0] and 0xFF.toByte()) shl 8) or (b[1] and 0xFF.toByte())).toChar()
//    }
//
//    /**
//     * bytesToChar: bytesToChar(byte[] b)的更好的实现方法. <br></br>
//     *
//     * @param b      整个byte数组，不用new 然后 system.arraycopy
//     * @param offset 从b数组的第几个字节开始
//     * @return
//     * @author "浦耀宗"
//     */
//    fun bytesToChar(b: ByteArray, offset: Int): Char {
//        return (b[0 + offset] and 0xFF.toByte() shl 8 or (b[1 + offset] and 0xFF.toByte())).toChar()
//    }
//
    /**
     * bytesToInt: byte数组转化为int 将低字节在前转为int. <br></br>
     *
     * @param res    整个byte数组，不用new 然后 system.arraycopy
     * @param offset 从b数组的第几个字节开始
     * @return 高字节在后的int
     * @author "浦耀宗"
     */
    fun bytesToInt(res: ByteArray): String {
        val sb = StringBuilder()
        sb.append("[ ")
        for (i in res) {
            sb.append(i.toInt()).append(" ")
        }
        sb.append("] ")
        return sb.toString()
//
//        return if (res.size < offset + 4) {
//            0
//        } else {
//            ((res[0 + offset].toInt() and 0xff)
//                    or ((res[1 + offset].toInt() shl 8) and 0xff00)
//                    or (res[2 + offset].toInt() shl 24).ushr(8)
//                    or (res[3 + offset].toInt() shl 24))
//        }
    }

    fun dumpHex(src: ByteArray): String {
        val num = "0123456789ABCDEF"
        val sb = StringBuilder()
        sb.append("[ ")
        for (aSrc in src) {
            val high = (aSrc.toInt() shr 4) and 0x0f
            val low = aSrc.toInt() and 0x0f
            sb.append(num[high]).append(num[low]).append(" ")
        }
        sb.append(" ]")

        return sb.toString()
    }
//
    /**
     * 4个字节 高字节在前
     *
     * @param b
     * @return
     */
    //    fun bytesToInt2(b: ByteArray): String {
////        var intValue = 0
//        val sb = StringBuilder()
//        sb.append("[ ")
//        for (i in b.indices) {
//            sb.append(b[i].toInt() and 0xFF shl 8 * (3 - i)).append(" ")
//        }
//        sb.append(" ]")
//        return sb.toString()
//    }
//
//
//    /**
//     * byte数组中取int数值，本方法适用于(低位在前，高位在后)的顺序，和和intToBytes（）配套使用
//     *
//     * @param src
//     * byte数组
//     * @param offset
//     * 从数组的第offset位开始
//     * @return int数值
//     */
//    fun bytesToInt(src: ByteArray, offset: Int): Int {
//        return (src[offset].toInt() and 0xFF) or
//                (src[offset + 1].toInt() and 0xFF shl 8) or
//                (src[offset + 2].toInt() and 0xFF shl 16) or
//                (src[offset + 3].toInt() and 0xFF shl 24)
//    }

    fun bytesToInt3(ary: ByteArray, offset: Int): Int {
        return (ary[offset].toInt() and 0xFF
                or (ary[offset + 1].toInt() shl 8 and 0xFF00)
                or (ary[offset + 2].toInt() shl 16 and 0xFF0000)
                or (ary[offset + 3].toInt() shl 24 and 0xFF000000.toInt()))
    }


    /**
     * 把byte转化成2进制字符串
     * @param b
     * @return
     */
    fun getBinaryStrFromByte2(b: Byte): String {
        var result = ""
        var a = b
        for (i in 0..7) {
            result = (a % 2).toString() + result
            a = (a.toInt() shr 1).toByte()
        }
        return result
    }

    /**
     * 把byte数组转化成2进制字符串
     * @param bArr
     * @return
     */
    fun getBinaryStrFromByteArr(bArr: ByteArray): String {
        val sb = StringBuilder()
        sb.append("[ ")
        for (b in bArr) {
            sb.append(getBinaryStrFromByte(b)).append(" ")
        }
        sb.append("]")
        return sb.toString()
    }

    /**
     * 把byte转化成2进制字符串
     * @param b
     * @return
     */
    fun getBinaryStrFromByte(b: Byte): String {
        var result = ""
        var a = b
        for (i in 0..7) {
            val c = a
            a = (a.toInt() shr 1).toByte()//每移一位如同将10进制数除以2并去掉余数。
            a = (a.toInt() shl 1).toByte()
            if (a == c) {
                result = "0" + result
            } else {
                result = "1" + result
            }
            a = (a.toInt() shr 1).toByte()
        }
        return result
    }

    fun byteToInt(b: ByteArray): String {
        val sb = StringBuilder()
        sb.append("[ ")
        for (i in b) {
            i.toInt() and 0xFF
            sb.append(i).append(" ")
        }
        sb.append(" ]")
        //Java 总是把 byte 当做有符处理；我们可以通过将其和 0xFF 进行二进制与得到它的无符值
        return sb.toString()
    }

//    /**
//     * byte数组中取int数值，本方法适用于(低位在后，高位在前)的顺序。和intToBytes2（）配套使用
//     */
//    fun bytesToInt2(src: ByteArray, offset: Int): Int {
//        val value: Int
//        value = (src[offset] and 0xFF shl 24 or (src[offset + 1] and 0xFF shl 16) or (src[offset + 2] and 0xFF shl 8) or (src[offset + 3] and 0xFF)).toInt()
//        return value
//    }

//    /**
//     * bytesToInt2: 4个字节 高字节在前. <br></br>
//     * 上面的方法的替代，这样就不用new byte了，直接把要转的 byte[] 传进来
//     *
//     * @param b      整个byte数组，不用new 然后 system.arraycopy
//     * @param offset 从b数组的第几个字节开始
//     * @return 转换过的int
//     * @author "浦耀宗"
//     */
//    fun bytesToInt2(b: ByteArray, offset: Int): Int {
//        return (0..3).sumBy { b[it + offset].toInt() and 0xFF shl 8 * (3 - it) }
//    }
//
//    /**
//     * byte2short: byte 转 short. 低位在前 <br></br>
//     *
//     * @param b
//     * @return
//     * @author "浦耀宗"
//     */
//    fun bytesToShort2(b: ByteArray, index: Int): Short {
//        // return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));
//        var s: Short = 0
//        var s0 = (b[0 + index] and 0xff).toShort()// 最低位
//        val s1 = (b[1 + index] and 0xff).toShort()
//        s0 = s0 shl 8
//        s = (s0 or s1)
//        return s
//    }
//
//    /**
//     * byte2short: byte 转 short.  高位在前 <br></br>
//     *
//     * @param b
//     * @return
//     * @author "浦耀宗"
//     */
//    fun bytesToShort(b: ByteArray, index: Int): Short {
//        // return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));
//        var s: Short = 0
//        val s0 = (b[0 + index] and 0xff.toByte()).toShort()// 最低位
//        var s1 = (b[1 + index] and 0xff.toByte()).toShort()
//        s1 = s1 shl 8
//        s = (s0 or s1)
//        return s
//    }
//
//    /**
//     * bytes2UShort: 把Byte转换为unsigned short，因为java 没有unsigned short，所以转换为char. <br></br>
//     *
//     * @param b
//     * @param index
//     * @return
//     * @author "浦耀宗"
//     */
//    fun bytesToUShort(b: ByteArray, index: Int): Char {
//        return (b[index + 1] and 0xFF.toByte() shl 8 or (b[index + 0] and 0xff.toByte()) and 0xFFFF).toChar()
//    }
//
//    /**
//     * bytesTo32BitLong: 把Byte转换为32bit的long，因为arm的long是32位的. <br></br>
//     *
//     * @param bb
//     * @param index
//     * @return
//     * @author "浦耀宗"
//     */
//    fun bytesTo32BitLong(bb: ByteArray, index: Int): Long {
//        return bb[index + 3].toLong() and 0xff shl 24 or (bb[index + 2].toLong() and 0xff shl 16) or (bb[index + 1].toLong() and 0xff shl 8) or (bb[index + 0].toLong() and 0xff shl 0)
//    }
//
//    /**
//     * bytesTo64BitLong: 看下，可能字节序不对. <br></br>
//     *
//     * @param b
//     * @param index
//     * @return
//     * @author "浦耀宗"
//     * @date 2014年5月12日 下午4:59:07
//     */
//    fun bytesTo64BitLong(b: ByteArray, index: Int): Long {
//        val buffer = ByteBuffer.allocate(8)
//        buffer.put(b, index, 8)
//        buffer.flip()// need flip
//        return buffer.long
//    }
//
//    /**
//     * 将byte数组转化成String
//     */
//    fun bytesToString(valArr: ByteArray, offset: Int, length: Int): String? {
//        var result: String? = null
//        try {
//            result = String(valArr, offset, length, "UTF-8")
//        } catch (e: UnsupportedEncodingException) {
//            e.printStackTrace()
//        }
//
//        return result
//    }
//
//    /**
//     * 将byte数组转化成String
//     */
//    fun bytesToString(valArr: ByteArray, offset: Int): String? {
//        var result: String? = null
//        var byteCount = 0
//        while (byteCount + offset < valArr.size) {
//            if (valArr[byteCount + offset].toInt() == 0) {
//                break
//            }
//            byteCount++
//        }
//
//        try {
//            result = String(valArr, offset, byteCount, "UTF-8")
//        } catch (e: UnsupportedEncodingException) {
//            e.printStackTrace()
//        }
//
//        return result
//    }
//
//    /**
//     * 将byte数组转化成String
//     */
//    fun bytesToString(valArr: ByteArray): String? {
//        var result: String? = null
//        var index = 0
//        while (index < valArr.size) {
//            if (valArr[index].toInt() == 0) {
//                break
//            }
//            index++
//        }
//
//        try {
//            result = String(valArr, 0, index, "UTF-8")
//        } catch (e: UnsupportedEncodingException) {
//            e.printStackTrace()
//        }
//
//        return result
//    }
//
//    /**
//     * char 转换为byte
//     *
//     * @param c
//     * @return
//     */
//    fun charToBytes(c: Char): ByteArray {
//        val b = ByteArray(2)
//        b[0] = (c.toInt() and 0xFF).toByte()
//        b[1] = (c.toInt() and 0xFF00 shr 8).toByte()
//        return b
//    }
//
//    @Throws(Exception::class)
//    fun getHexString(b: ByteArray): String {
//        var result = ""
//        for (i in b.indices) {
//            result += Integer.toString((b[i] and 0xff.toByte()) + 0x100, 16).substring(1)
//        }
//        return result.toUpperCase()
//    }

    fun getSn(data: ByteArray): String {
        var sn = ""
        for (i in data) {
            sn += Integer.toHexString(i.toInt()).toString()
            //大写
        }
        return sn.toUpperCase()
    }


    /**
     *  public static String dumpHex(byte[] src) {
    String num = "0123456789ABCDEF";
    StringBuilder sb = new StringBuilder();
    sb.append("[ ");
    for (byte aSrc : src) {
    int high = aSrc >> 4 & 0x0f;
    int low = aSrc & 0x0f;
    sb.append(num.charAt(high)).append(num.charAt(low)).append(" ");
    }
    sb.append(" ]");

    return sb.toString();
    }
     */
    /**
     * @param inStream
     * @return 读入的字节数组
     * @throws Exception
     * @方法功能 InputStream 转为 byte
     */
    @Throws(Exception::class)
    fun inputStreamToByte(inStream: InputStream?): ByteArray? {
        var count = 0
        while (count == 0) {
            if (inStream != null) {
                count = inStream.available()
            }
        }
        var b: ByteArray? = null
        if (count > 2048) {
            b = ByteArray(2048)
        } else {
            if (count != -1) {
                b = ByteArray(count)
            }
        }
        if (null != b) {
            inStream!!.read(b)
        }
        return b
    }

    /**
     * 将int转为低字节在前，高字节在后的byte数组
     */
    fun intToBytes(n: Int): ByteArray {
        val b = ByteArray(4)
        b[0] = (n and 0xff).toByte()
        b[1] = (n shr 8 and 0xff).toByte()
        b[2] = (n shr 16 and 0xff).toByte()
        b[3] = (n shr 24 and 0xff).toByte()
        return b
    }

    /**
     * long2Bytes:(这里用一句话描述这个方法的作用). <br></br>
     *
     * @param num
     * @return
     * @author "浦耀宗"
     */
    fun longToBytes(num: Long): ByteArray {

        val b = ByteArray(8)
        for (i in 0..7) {
            b[i] = num.ushr(56 - i * 8).toByte()
        }
        return b
    }
//
//    fun shortToBytes(s: Short): ByteArray {
//        val ret = ByteArray(2)
//        ret[0] = (s and 0xff).toByte()
//        ret[1] = (s shr 8 and 0xff).toByte()
//
//        return ret
//    }
//
//    /**
//     * 将String转化成byte数组
//     *
//     * @param str
//     * @return
//     */
//    fun stringToBytes(str: String?): ByteArray? {
//        var temp: ByteArray? = null
//        try {
//            if (str == null) {
//                temp = byteArrayOf(0)
//            } else {
//                temp = str.toByteArray(charset("UTF-8"))
//            }
//        } catch (e: UnsupportedEncodingException) {
//            e.printStackTrace()
//        }
//
//        return temp
//    }
//
//    //    public String DToB(String a) {
//    //        String b = Integer.toBinaryString(Integer.valueOf(toD(a, 16)));
//    //        return b;
//    //    }
//
//
//    fun dumpHex(src: ByteArray): String {
//        val num = "0123456789ABCDEF"
//        val sb = StringBuilder()
//        sb.append("[ ")
//        for (aSrc in src) {
//            val high = aSrc shr 4 and 0x0f
//            val low = aSrc and 0x0f
//            sb.append(num[high]).append(num[low.toInt()]).append(" ")
//        }
//        sb.append(" ]")
//
//        return sb.toString()
//    }
//
//    fun dumpHex(src: Byte): String {
//        val num = "0123456789ABCDEF"
//        val sb = StringBuilder()
//        sb.append("[ ")
//        val high = src shr 4 and 0x0f
//        val low = src and 0x0f
//        sb.append(num[high]).append(num[low.toInt()]).append(" ")
//        sb.append(" ]")
//
//        return sb.toString()
//    }
}
